public class ReadMe {
    /**
     * 2022-10-25 计算机基础和环境变量
     * 1.第一台电脑：詹姆斯高斯林
     * 2.计算机硬件组成
     * 3.软件：系统软件和应用软件
     * 4.cs和bs
     * 5.jdk  jre  jvm 理解意思，能够用一句话说出来
     * 6.环境配置
     * 7.helloworld
     * 8.dos命令
     * 9.注释
     * 10.预习明天的内容：基础语法：数据类型等
     */
    /**
     * 2022-10-26 基础语法
     * 创建包：全部小写。每个包都有属于自己的意思；
     * class 用于定义类
     * package  用于定义包
     * public 属于权限修饰符/访问修饰符
     * static 特征修饰符/非访问修饰符
     * void  返回值类型  表示没有返回值
     * -----------------------
     * 标识符：就是用来定义一段代码，用来命名的
     * 关键字：全小写  int
     * 包：全小写 good.student
     * 类名:大驼峰 GoodStudent
     * 属性，方法名：小驼峰 goodStudent
     * 常量：全部大写  GOOD_STUDENT
     * 数据类型 变量名 = 数据值
     * int  age=12;
     * 1g=1024m,1m=1024kb ,1kb=1024byte;1byte=8bit
     */
    /**
     * 2022-10-27 运算符和分支
     * 1.整数的默认数据类型是int
     * 2.小数的默认数据类型是double
     * 3.将小的取值范围赋值给大的取值范围，隐式转换  向上转型
     * 4.将大的取值范围赋值给小的取值范围，强制转换  向下转型
     * 5.&  两边都要执行 都为true，则结果为true，
     * 6.&&  只要左边为false，则右边不执行，只要有一个为false，则结果为false
     * 7.||  只要左边为true，则右边不执行，只要有一个为true，则结果为true
     */
    /**
     * 2022-10-28 循环语句
     * 1.for
     * 2.while
     * 3.do while
     * 4.do while循环至少执行一次
     * 5.break，跳出当前循环
     * 6.continue 跳出当次循环
     * 7.return 跳出当前方法
     * 8.随机数
     */
    /**
     * 2022-10-31 数组和二维数组
     * 1.数组的定义  int [] arr=new int[]{1,2,3};
     * 2.数组的获取 arr[0]用索引
     * 3.索引，就是数组里面的内容的下标，从0开始
     * 4.获取数组的内容：需要进行遍历（循环）
     * 5.如果循环，知道要循环多少次，则用for循环
     *      for(int a=0;a<元素的长度;a++)
     *      如果不知道要循环多少次，用什么？用while，只要有一个不满足条件即可
     * 6.随机数
     * 7.二维数组：定义，遍历，求和，最大值，赋值，内存图
     */
    /**
     * 2022-11-1 方法
     * 1.以后建议不要 将常量放到方法里面，一般通过配置文件进行调用
     * 2.一个方法里面最好只干一件事情，不要把所有代码放在一起
     * 3.如果是不定参数，那么这个参数一定写在最后面
     */
    /**
     * 2022-11-3 面向对象基础
     * 1.以后你们做任何一件事情，首先找对象,然后找到对象的行为和特征
     * 2.所有的引用类型的默认值为null
     * 3.找到对象后，我们需要将对象里面的属性和方法进行定义
     * 4.变量就近原则
     * 5.构造方法：类名和方法名一致，没有return，没有void，没有返回值类型
     * 6.构造方法是有返回值，只不过返回的是对象本身，不需要用return返回
     * 7.类里面默认有一个无参数的构造方法
     * 8.如果手动写了一个有参数的构造方法，则默认的无参数的构造方法失效
     * 9.如果想要正确，则手动添加一个无参数的构造方法
     * 10：熟练使用构造方法：以后创建对象的时候最好将无参数和全参数的构造方法都手动创建
     * --------------------------------------------------------
     * 对象，其实就是类的一个实例，是在创建类后才有
     * Student student = new Student();
     * 类里面包含属性，行为（方法）
     * 如果要调用属性和方法，则通过对象.属性，对象.方法（）
     * ----------------------------------------
     * 权限修饰符：
     * public  所有的地方都可以访问
     * private  只能在当前类可以方法
     * ---------------
     * 标准Javabean对象
     * 1.所有属性全部用private
     * 2.构造方法（无参数和全参数）
     * 3.set和get方法
     * 4.所有属性的数据类型最好用引用数据类型
     */
    /**
     * 2022-11-4 字符串
     * 1.创建对象就是对对象进行实例化
     * 2.字符必须单引号，里面必须有内容 字符串可以理解为多个字符组成
     * 3.final修饰属性的时候，属性的地址值不能改变，
     * 4.String bb=new String("aa");创建了几个对象？
     *      1.如果aa在常量池（方法区）里面不存在，则会创建两个对象，
     *      2.如果aa存在，则直接在堆内存里面创建对象一次，
     * 5.String aa="aa";栈里面是String aa；没有堆，常量池里面存aa
     * 6. Integer a=100;
     *    Integer b=100;
     *    System.out.println(a==b);
     *    Integer 赋值时，如果值在128（byte）的范围，则两个数相等，否则就不等
     *    因为Integer会默认创建一个缓存，
     *    如果大于128，缓存里面没有，则会创建一个新对象 new Integer(300);
     *    -----------------------------------------
     * 7.charAt()
     * 8.toCharArray();
     * 9.subString(startIndex,endIndex);
     * 10.replace
     * 11.split
     * 12.trim
     * 13.toString
     * 14.equals
     * 15.==  equals的区别？
     * 16.str.concat("aa") 拼接字符串
     * 17.str.startsWith("aa") 以aa开始
     * 18.str.indexOf("张")
     * 19. Integer Integer.valueOf();
     * 20. int Integer.parseInt();
     */
    /**
     * 2022-11-7 集合基础
     * 1.以前如果需要存储不固定的数据
     *      1）创建一个数组，将需要的数据存入数组
     *      2）如果数组一件存满，需要在存一个数组
     *      3）新创建一个数组，长度+1
     *      4）将以前的数据存入新数组，然后在最后一个存入新数据
     *     注意：如果每次都要增加一个数据，则会重复1-4的流程
     *     既然会重复代码，那么思考能不能重写写一个公共的类里面提取公共的方法直接进行调用
     * 2.推荐集合：集合就是对数组的封装
     * 3.ArrayList<Integer>里面的数据类型必须是引用数据类型，不能是基本数据类型
     * 4.ArrayList 每次remove都会改变ArrayList的长度
     * 5.ArrayList   set(index,object);返回修改之前的元素set就是修改元素的意思
     * 6.add(Object)增加元素，默认增加到最后
     * 7.add(index,Object),指定增加到某个索引的地方，不能超过当前集合的长度
     * 8.熟练掌握集合基础的增删改查
     *      增加：add(o),add(i,o)
     *      删:remove(i),remove(o)
     *      改：set(i,o)
     *      查：get(i)
     * 9.学生管理系统
     *      思路：
     *      1)每次都可以用户选择，则需要一个死循环
     *      2)需要用户输入信息，则需要 Scanner scanner = new Scanner(System.in);
     *      3)用户添加学生的时候，需要一个容器接收（集合）
     *      4）因为用户每次选择的不一样，则用多分支switch
     *      5）每次的功能不要写在一个方法里面，应该创建不同的方法
     *      6.退出Java虚拟机  System.exit(0);
     * 10.二级制向右移动一位，就等于除以2，
     * 11.集合的底层就是对数组的封装，每次跨容都是跨1.5倍
     * 12.Arrays.copyOf(elementData, newCapacity);将以前的数组elementData复制到新数组newCapacity
     *
     *
     */
    /**
     * 2022-11-8 面向对象之继承
     * 1.面需对象的三大特征：继承，封装，多态（抽象）
     * 2.子类继承父类的属性和方法:父类私有的不能继承
     * 3.Child   Parent  GrandFather Object
     *      Child  子类
     *      Parent  父类
     *      GrandFather 超类
     *      Object  基类
     * 4.继承一定是一种包含关系，a属于b，但a又可以又多余的功能
     * 5.this
     * 6.super 子类的构造方法默认不写super();
     * 7.重载：方法名相同，参数类型和个数不同，和返回值无关
     * 8.重写：方法名相同，参数类型和个数相同（一般情况下）
     * 9.重写目的：父类满足不了子类的要求，子类可以夸张自己的功能
     * 10.怎么判断该方法一定重写了呢？@Override
     * 11.重写 ：子类的修饰符必须大于等于父类,子类的返回值必须小于等于父类的返回值范围
     * 12.Java不支持普通类的多继承，但支持接口的多继承
     * ----------------------------------------------------
     * 继承：子类继承父类的功能，子类可以扩展父类的功能：extends
     * super();this();子类的构造方法默认调用一个父类的无参数的构造方法
     * Java多继承
     * 重写
     * ------------------------------------
     * 修饰符：权限修饰符和特征修饰符（状态修饰符）
     * 访问修饰符和非访问修饰符
     * 修饰符：控制谁可以访问当前的属性或者方法：控制权限（当前项目）
     * public 任何类都可以访问
     * private  当前类可以访问
     * 默认不写  跨包后不能访问（如果是子类可以访问）
     * protected  一般用于父类和子类  受保护的
     * 修饰类，只能是public和默认不写
     * =---------------
     * final 最终的
     *      修饰方法的时候，表示子类不能重写：子类可以用final修饰
     *      修饰属性的时候：1.必须赋初始值，2.不能重新赋值
     *      修饰局部变量的时候：不能重新赋值，可以不用赋值，但是用的时候必须赋初始值
     *      修饰类的时候不能被继承
     * static  静态的
     *      在内存里面会进行资源共享
     *      无论实例化多少次，只要不进行重新赋值，在任何一个类里面调用它都可以得到相同值
     *      静态方法调用静态属性，直接类名.属性名
     *      静态方法调用非静态属性，new对象.属性名
     *      非静态方法调用静态属性和方法。直接类名.属性名
     *      非静态方法调用非静态属性和方法方法。对象.属性和对象.方法
     *
     * 静态代码块先于代码块先于构造方法:和代码书写顺序无关
     * 静态代码块只执行一次
     * 代码块和构造方法，每一次创建都会执行
     *
     *
     *
     */
    /**
     * 2022-11-9 面向对象多态
     * 1.多态的描述
     *      1）继承/实现
     *      2）方法的重写
     *      3）父类引用指向子类引用
     * 2.优点  提高扩展性
     * 3.缺点  不能使用子类的特有功能
     * 4.向上和向下转型
     * 5.抽象：将共同的特性或者行为抽象到一个父类，但是行为没有进行实现（方法没有方法体）
     * 6.抽象类  一定有abstract关键字修饰
     * 7.抽象类不一定有抽象方法
     * 8.有抽象方法的类一定是抽象类
     * 9.抽象类不能被实例化（不能通过new关键字创建对象，如果非要创建，则必须实现里面所有的抽象方法）
     * 10.子类继承抽象类，一定是实现所有父类里面的抽象方法
     * ------------------------------------
     * 11.接口里面的方法，默认修饰符  public 默认为抽象方法
     * 12.如果抽象类里面有很多的抽象方法，则我们可以将所有的抽象方法进行提取，放入接口
     * 13.接口是一个特殊的抽象类，
     * 14.接口可以有多实现
     * 15.最好一个接口里面只做一个功能（和以前方法和类差不多，只做一件事情）
     * 16.如果一个类实现了一个接口，如果不想实现里面的方法，则该类必须是接口或者抽象类
     * 17.接口里面的属性，默认为常量  public static final AA=null;
     * 18.接口和抽象类的区别？
     * 19.  1）如果抽象类里面全是抽象方法用接口
     *      2）如果抽象类里面全是常量用枚举
     *      3）如果类主要是对类进行抽取公共部分，则用抽象类
     *
     *
     */
    /**
     * 2022-11-10 接口
     * 1.内部类
     *      1）局部内部类
     *      2）成员内部类
     *      3）局部内部类里面可以调用外部类的成员方法或者属性
     *      4）外部类要调用局部内部类，需要创建对象，实例化
     *      5）外部类可不可以调用局部内部类的属性和方法？
     * 2.匿名内部类   没有名字
     *      1）前提就是要重写里面的方法
     *------------------------------------------------------------------
     * 总结：
     * 一：继承
     *      1）父类子类 关键字  extends
     *      2）关键字
     *              1）final
     *                  1）修饰类  子类不能继承父类
     *                  2）修饰属性  表示不能被重新赋值 最终的
     *                  3）修饰方法  表示方法不能被重写
     *              2）static
     *                  1）静态的  资源共享
     *                  2）调用方法 ：
     *                      1）静态调用静态   类名.
     *                      2）静态调用非静态  new 对象().
     *                      3）非静态调用静态  类名.
     *                      4）非静态调用非静态  new 对象().
     * 二：多态
     *      1  多态
     *           1）必须是继承或实现关系  子类与父类的关系  extents  implements
     *           2）父类的引用指向子类  Parent parent=new Child();
     *           3）重写父类的方法 @Override
     *      2 抽象
     *          1）关键字 abstract
     *          2）抽象类里面不一定有抽象方法
     *          3）抽象方法一定是抽象类
     *      3 转型
     *      4 super  this
     * 三：接口
     *      1）是一个类
     *      2）是一个特殊的抽象类
     *      3）是抽象的行为
     *      4）可以有普通方法
     *      5）可以有静态方法
     *      6）可以有私有的方法  java jdk9以后
     *      7）多实现，多继承
     *      8）可以有属性  默认为常量
     *      9）抽象类和接口的区别？
     * 四：内部类
     *      1）局部
     *      2）成员
     *      3）匿名
     *      4）主要考察的是调用关系
     *-----------------------------------------------------------
     * lambda表达式
     *      1）（）->{}
     *      2）有一个接口
     *      3）只能有一个抽象方法
     *      4)必须是接口，不能是抽象类
     *      ------------
     *      省略
     *      1）大括号可以省略，代码只有一行的时候
     *      2）return可以省略，同时代码只有一行，大括号也必须省略
     *      3)如果只有一个参数，则小括号可以省略
     *      4)参数类型可以同时省略。
     * lambda表达式和匿名内部类的区别？
     *      1）所需类型不一样 ：lambda只能说接口
     *      2）使用限制不一样：lambda只能是一个抽象方法
     *      3）实现原理不一样：lambda 只有一个class文件
     * ----------------------------------------------------
     * Java 关键字
     * 1： 八大数据据类型  8
     * 2：权限修饰符       3
     * 3：语法结构：顺序 分支  循环 11    if  else switch case break default return continue  for while  do
     * 4: 特征修饰符  5 final  static  abstract instanceof synchronized
     * 5：继承与实现   2 extends implements
     * 6.类  4 class  package void interface
     * 7. 11 new this super throw  throws  try catch finally null true false
     *
     */
    /**
     * 2022-11-11 常用API
     * 1.api  应用程序接口  别人已经写好的方法，提供给调用
     * 2.如果不能使用构造方法调用类里面成员，那么里面的成员必须为static
     * 3.Math 数学方法 ：最小值，最大值，平均数
     * 4.System  1668148241845从1970-1-1-0：0：0
     * 5.Object 里面的常用方法？ 8种
     *      1)getClass 反射的时候用，拿到当前类
     *      2）hashCode  得到hash值
     *      3）equals   比较里面的内容的值
     *      4）clone    克隆 复制
     *      5）toString  将对象转换为字符串
     *      6）notify  notifyAll  唤醒线程
     *      7）wait  线程等待
     *      8）finalize  垃圾回收的时候用到
     * 6.String和StringBuilder和StringBuffer的区别？
     *      1.String 每次赋值都会创建对象，因为是final修饰
     *      2.StringBuilder 线程非安全   效率快
     *      3.StringBuffer  线程安全
     * 7.Objects.toString(aa, "ab") 如果aa为空（null），则返回ab字符串，否则返回aa对象的字符串
     * 8.很多时候，浮点型数据类型不精确，容易精度丢失，所以引入BigDecimal
     * 9.new BigDecimal("10.123");推荐用字符串的构造方法
     * 10.非数字不能转换为int类型
     * 11.将字符串转换为数组，用split进行分割
     * ------------------------------------------------
     * 1）Math里面的方法
     * 2）Object里面的八个方法
     * 3）拆箱和装箱
     * 4）System  退出，取得毫秒数
     * 5）排序：冒泡排序（掌握）快速排序（了解）
     * 6）二分查找
     * 7）Objects 这个很少用到
     * 8）BigDecimal 大多数用于价格
     * 9)递归：（掌握）
     */
    /**
     * 2022-11-14 常用异常和日期处理
     * 1.编译时异常：受检异常：显示处理，一般写在方法后面，抛出异常：throws
     * 2.运算时异常：非受检异常：表示编译时不会出现异常，只会在运行时报错
     * 3.异常一般情况下，哪里出现，哪里处理，只有你解决不了，则向上抛出
     * 4.每一个可能出现的异常应该分开处理，写多个try catch
     * 5.自定义异常的目的就是显示更多的信息:在springboot的时候，用全局异常
     * -----------------------------------------
     * 日期：1668408878859  1900-1-1
     * 注解：Deprecated表示已经过失，不推荐使用，但可以用
     * 6.每一个方法只做一件事情
     * 7.日期：Date  SimpleDateFormat  LocalDateTime  Clock  Duration
     */
    /**
     * 2022-11-15 集合list
     * 1.collection  常用方法  add  remove
     * 2.List  add(index,Object);
     * 3.ArrayList  数组
     * 4.LinkedList 链表
     * 5.数据结构   栈  队列  数组  链表
     * 6.迭代器：  三种遍历的区别？for   forEach  iterator
     * 7.泛型 ：类  接口  方法
     *
     */
    /**
     * 2022-11-16 集合set
     * 1.set可以去重
     * 2.set默认排序
     * 3.如果set里面是对象，则需要实现Comparable接口，并重写里面的compareTo方法
     * 4.在compareTo里面写排序规则
     * 上面无参数的构造方法Set<Student> set=new TreeSet<>();这个自然排序
     * 5.如果有参数的构造方法，则叫做比较强排序
     * --------------------------------------
     * treeSet 数据结构：数结构
     * 二叉树
     * 二叉查找树，排序树，搜索树
     * 平衡二叉树：理解怎么添加节点，怎么旋转
     * ----------------------------------
     * 总结：
     * 1：Set 特点：去重，排序，没有索引
     * 2.TreeSet  树-二叉树-排序-红黑-平衡--旋转--添加节点
     * 3.自然排序和比较器排序
     * 4.HashSet  重写equals和hashCode方法
     * ---------------------------
     */
    /**
     * 2022-11-17 集合map
     * 1.集合是否可以存相同的元素？
     * 2.集合是否可以存null？
     *
     *
     */


}
